﻿using System;
using MoonSharp.Interpreter;
using UnityEngine;

namespace Lua
{
	// Token: 0x020002F3 RID: 755
	[MoonSharpUserData]
	public static class Mathf
	{
		// Token: 0x170002B3 RID: 691
		// (get) Token: 0x06001229 RID: 4649 RVA: 0x00080DB3 File Offset: 0x0007EFB3
		public static float Deg2Rad
		{
			get
			{
				return 0.017453292f;
			}
		}

		// Token: 0x170002B4 RID: 692
		// (get) Token: 0x0600122A RID: 4650 RVA: 0x00080DBA File Offset: 0x0007EFBA
		public static float Epsilon
		{
			get
			{
				return Mathf.Epsilon;
			}
		}

		// Token: 0x170002B5 RID: 693
		// (get) Token: 0x0600122B RID: 4651 RVA: 0x00080DC1 File Offset: 0x0007EFC1
		public static float Infinity
		{
			get
			{
				return float.PositiveInfinity;
			}
		}

		// Token: 0x170002B6 RID: 694
		// (get) Token: 0x0600122C RID: 4652 RVA: 0x00080DC8 File Offset: 0x0007EFC8
		public static float NegativeInfinity
		{
			get
			{
				return float.NegativeInfinity;
			}
		}

		// Token: 0x170002B7 RID: 695
		// (get) Token: 0x0600122D RID: 4653 RVA: 0x00080DCF File Offset: 0x0007EFCF
		public static float PI
		{
			get
			{
				return 3.1415927f;
			}
		}

		// Token: 0x170002B8 RID: 696
		// (get) Token: 0x0600122E RID: 4654 RVA: 0x00080DD6 File Offset: 0x0007EFD6
		public static float Rad2Deg
		{
			get
			{
				return 57.29578f;
			}
		}

		// Token: 0x0600122F RID: 4655 RVA: 0x00080DDD File Offset: 0x0007EFDD
		public static float Abs(float f)
		{
			return Mathf.Abs(f);
		}

		// Token: 0x06001230 RID: 4656 RVA: 0x00080DE5 File Offset: 0x0007EFE5
		public static float Acos(float f)
		{
			return Mathf.Acos(f);
		}

		// Token: 0x06001231 RID: 4657 RVA: 0x00080DED File Offset: 0x0007EFED
		public static bool Approximately(float a, float b)
		{
			return Mathf.Approximately(a, b);
		}

		// Token: 0x06001232 RID: 4658 RVA: 0x00080DF6 File Offset: 0x0007EFF6
		public static float Asin(float f)
		{
			return Mathf.Asin(f);
		}

		// Token: 0x06001233 RID: 4659 RVA: 0x00080DFE File Offset: 0x0007EFFE
		public static float Atan(float f)
		{
			return Mathf.Atan(f);
		}

		// Token: 0x06001234 RID: 4660 RVA: 0x00080E06 File Offset: 0x0007F006
		public static float Atan2(float y, float x)
		{
			return Mathf.Atan2(y, x);
		}

		// Token: 0x06001235 RID: 4661 RVA: 0x00080E0F File Offset: 0x0007F00F
		public static float Ceil(float f)
		{
			return Mathf.Ceil(f);
		}

		// Token: 0x06001236 RID: 4662 RVA: 0x00080E17 File Offset: 0x0007F017
		public static float Clamp(float value, float min, float max)
		{
			return Mathf.Clamp(value, min, max);
		}

		// Token: 0x06001237 RID: 4663 RVA: 0x00080E21 File Offset: 0x0007F021
		public static float Clamp01(float value)
		{
			return Mathf.Clamp01(value);
		}

		// Token: 0x06001238 RID: 4664 RVA: 0x00080E29 File Offset: 0x0007F029
		public static int ClosestPowerOfTwo(int value)
		{
			return Mathf.ClosestPowerOfTwo(value);
		}

		// Token: 0x06001239 RID: 4665 RVA: 0x00080E31 File Offset: 0x0007F031
		public static float Cos(float f)
		{
			return Mathf.Cos(f);
		}

		// Token: 0x0600123A RID: 4666 RVA: 0x00080E39 File Offset: 0x0007F039
		public static float DeltaAngle(float current, float target)
		{
			return Mathf.DeltaAngle(current, target);
		}

		// Token: 0x0600123B RID: 4667 RVA: 0x00080E42 File Offset: 0x0007F042
		public static float Exp(float power)
		{
			return Mathf.Exp(power);
		}

		// Token: 0x0600123C RID: 4668 RVA: 0x00080E4A File Offset: 0x0007F04A
		public static float Floor(float f)
		{
			return Mathf.Floor(f);
		}

		// Token: 0x0600123D RID: 4669 RVA: 0x00080E52 File Offset: 0x0007F052
		public static float InverseLerp(float a, float b, float value)
		{
			return Mathf.InverseLerp(a, b, value);
		}

		// Token: 0x0600123E RID: 4670 RVA: 0x00080E5C File Offset: 0x0007F05C
		public static bool IsPowerOfTwo(int value)
		{
			return Mathf.IsPowerOfTwo(value);
		}

		// Token: 0x0600123F RID: 4671 RVA: 0x00080E64 File Offset: 0x0007F064
		public static float Lerp(float a, float b, float t)
		{
			return Mathf.Lerp(a, b, t);
		}

		// Token: 0x06001240 RID: 4672 RVA: 0x00080E6E File Offset: 0x0007F06E
		public static float LerpAngle(float a, float b, float t)
		{
			return Mathf.LerpAngle(a, b, t);
		}

		// Token: 0x06001241 RID: 4673 RVA: 0x00080E78 File Offset: 0x0007F078
		public static float LerpUnclamped(float a, float b, float t)
		{
			return Mathf.LerpUnclamped(a, b, t);
		}

		// Token: 0x06001242 RID: 4674 RVA: 0x00080E82 File Offset: 0x0007F082
		public static float Log(float f, float p)
		{
			return Mathf.Log(f, p);
		}

		// Token: 0x06001243 RID: 4675 RVA: 0x00080E8B File Offset: 0x0007F08B
		public static float Log10(float f)
		{
			return Mathf.Log10(f);
		}

		// Token: 0x06001244 RID: 4676 RVA: 0x00080E93 File Offset: 0x0007F093
		public static float Max(float a, float b)
		{
			return Mathf.Max(a, b);
		}

		// Token: 0x06001245 RID: 4677 RVA: 0x00080E9C File Offset: 0x0007F09C
		public static float Max(params float[] values)
		{
			return Mathf.Max(values);
		}

		// Token: 0x06001246 RID: 4678 RVA: 0x00080EA4 File Offset: 0x0007F0A4
		public static float Min(float a, float b)
		{
			return Mathf.Min(a, b);
		}

		// Token: 0x06001247 RID: 4679 RVA: 0x00080EAD File Offset: 0x0007F0AD
		public static float Min(params float[] values)
		{
			return Mathf.Min(values);
		}

		// Token: 0x06001248 RID: 4680 RVA: 0x00080EB5 File Offset: 0x0007F0B5
		public static float MoveTowards(float current, float target, float maxDelta)
		{
			return Mathf.MoveTowards(current, target, maxDelta);
		}

		// Token: 0x06001249 RID: 4681 RVA: 0x00080EBF File Offset: 0x0007F0BF
		public static int NextPowerOfTwo(int value)
		{
			return Mathf.NextPowerOfTwo(value);
		}

		// Token: 0x0600124A RID: 4682 RVA: 0x00080EC7 File Offset: 0x0007F0C7
		public static float PerlinNoise(float x, float y)
		{
			return Mathf.PerlinNoise(x, y);
		}

		// Token: 0x0600124B RID: 4683 RVA: 0x00080ED0 File Offset: 0x0007F0D0
		public static float PingPong(float t, float length)
		{
			return Mathf.PingPong(t, length);
		}

		// Token: 0x0600124C RID: 4684 RVA: 0x00080ED9 File Offset: 0x0007F0D9
		public static float Pow(float f, float p)
		{
			return Mathf.Pow(f, p);
		}

		// Token: 0x0600124D RID: 4685 RVA: 0x00080EE2 File Offset: 0x0007F0E2
		public static float Repeat(float t, float length)
		{
			return Mathf.Repeat(t, length);
		}

		// Token: 0x0600124E RID: 4686 RVA: 0x00080EEB File Offset: 0x0007F0EB
		public static float Round(float f)
		{
			return Mathf.Round(f);
		}

		// Token: 0x0600124F RID: 4687 RVA: 0x00080EF3 File Offset: 0x0007F0F3
		public static float Sign(float f)
		{
			return Mathf.Sign(f);
		}

		// Token: 0x06001250 RID: 4688 RVA: 0x00080EFB File Offset: 0x0007F0FB
		public static float Sin(float f)
		{
			return Mathf.Sin(f);
		}

		// Token: 0x06001251 RID: 4689 RVA: 0x00080F03 File Offset: 0x0007F103
		public static float Sqrt(float f)
		{
			return Mathf.Sqrt(f);
		}

		// Token: 0x06001252 RID: 4690 RVA: 0x00080F0B File Offset: 0x0007F10B
		public static float SmoothStep(float from, float to, float t)
		{
			return Mathf.SmoothStep(from, to, t);
		}

		// Token: 0x06001253 RID: 4691 RVA: 0x00080F15 File Offset: 0x0007F115
		public static float Tan(float f)
		{
			return Mathf.Tan(f);
		}
	}
}
